Data-driven testing without data configuration

ABSTRACT

In software development, the provision of a testing tool which includes a method for defining a data source dynamically during an execution run, instead of programming such a definition within test script.

BACKGROUND

In software application development, changes in a UI (user interface) are generally considered to be inevitable. This also proves to be a significant challenge for any testing team, since whenever UI changes then a test case almost certainly will fail. As a result, the tester will need to update a verification point in accordance with the UI changes in order to promote a pass of the test down the road.

SUMMARY

Broadly contemplated herein, in accordance with at least one embodiment of the present invention, is the provision of a testing tool which includes a method for defining a data source dynamically during an execution run, instead of programming such a definition within test script.

In summary, this disclosure describes a method comprising: accepting software; and testing the software; the testing comprising: creating a verification point; storing reference data in the verification point; and subsequently employing the reference data in validating the software.

This disclosure also describes an apparatus comprising: a main memory; a software testing arrangement in communication with the main memory; the software testing arrangement acting to: create a verification point; store reference data in the verification point; and subsequently employ the reference data in validating software.

Furthermore, this disclosure also describes a program storage device readable by machine, tangibly embodying a program of instructions executable by the machine to perform a method comprising: accepting software; and testing the software; the testing comprising: creating a verification point; storing reference data in the verification point; and subsequently employing the reference data in validating the software.

For a better understanding of the present invention, together with other and further features and advantages thereof, reference is made to the following description, taken in conjunction with the accompanying drawings, and the scope of the invention will be pointed out in the appended claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 schematically illustrates a computer system.

FIG. 2 shows one of several ways of capturing data for UI objects (in XML format).

FIG. 3 shows a flow of events for executing a process in accordance with an embodiment of the present invention

FIG. 4 shows two embodiments in which the application context may be captured for creating a unique handle to one or more objects.

DETAILED DESCRIPTION

It will be readily understood that the components of the present invention, as generally described and illustrated in the Figure herein, may be arranged and designed in a wide variety of different configurations. Thus, the following more detailed description of the embodiments of the apparatus, system, and method of the present invention, as represented in FIG. 1, is not intended to limit the scope of the invention, as claimed, but is merely representative of selected embodiments of the invention.

Reference throughout this specification to “one embodiment” or “an embodiment” (or the like) means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present invention. Thus, appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment.

Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In the following description, numerous specific details are provided, such as examples of programming, software modules, user selections, network transactions, database queries, database structures, hardware modules, hardware circuits, hardware chips, etc., to provide a thorough understanding of embodiments of the invention. One skilled in the relevant art will recognize, however, that embodiment of the invention can be practiced without one or more of the specific details, or with other methods, components, materials, etc. In other instances, well-known structures, materials, or operations are not shown or described in detail to avoid obscuring aspects of embodiments of the invention.

The illustrated embodiments of the invention will be best understood by reference to the drawings, wherein like parts are designated by like numerals or other labels throughout. The following description is intended only by way of example, and simply illustrates certain selected embodiments of devices, systems, and processes that are consistent with the invention as claimed herein.

Referring now to FIG. 1, there is depicted a block diagram of an illustrative embodiment of a computer system 12, which may be employed in accordance with one or more embodiments of the present invention. It is to be understood that the system 12 shown in FIG. 1 is provided by way of an illustrative and non-restrictive example, and that of course other types of computer systems can be employed with the embodiments of the present invention set forth herein.

The embodiment depicted in FIG. 1 may be a notebook computer system, such as one of the ThinkPad® series of personal computers previously sold by the International Business Machines Corporation of Armonk, N.Y., and now sold by Lenovo (US) Inc. of Morrisville, N.C.; however, as will become apparent from the following description, the embodiments of the invention may be applicable to any data processing system. Notebook computers, as may be generally referred to or understood herein, may also alternatively be referred to as “notebooks”, “laptops”, “laptop computers” or “mobile computers” herein, and these terms should be understood as being essentially interchangeable with one another.

As shown in FIG. 1, computer system 12 includes at least one system processor 42, which is coupled to a Read-Only Memory (ROM) 40 and a system memory 46 by a processor bus 44. System processor 42, which may comprise one of the AMD™ line of processors produced by AMD Corporation or a processor produced by Intel Corporation, is a general-purpose processor that executes boot code 41 stored within ROM 40 at power-on and thereafter processes data under the control of operating system and application software stored in system memory 46. System processor 42 is coupled via processor bus 44 and host bridge 48 to Peripheral Component Interconnect (PCI) local bus 50.

PCI local bus 50 supports the attachment of a number of devices, including adapters and bridges. Among these devices is network adapter 66, which interfaces computer system 12 to a LAN, and graphics adapter 68, which interfaces computer system 12 to display 69. Communication on PCI local bus 50 is governed by local PCI controller 52, which is in turn coupled to non-volatile random access memory (NVRAM) 56 via memory bus 54. Local PCI controller 52 can be coupled to additional buses and devices via a second host bridge 60.

Computer system 12 further includes Industry Standard Architecture (ISA) bus 62, which is coupled to PCI local bus 50 by ISA bridge 64. Coupled to ISA bus 62 is an input/output (I/O) controller 70, which controls communication between computer system 12 and attached peripheral devices such as a keyboard and mouse. In addition, I/O controller 70 supports external communication by computer system 12 via serial and parallel ports. A disk controller 72 is in communication with a disk drive 200. Of course, it should be appreciated that the system 12 may be built with different chip sets and a different bus structure, as well as with any other suitable substitute components, while providing comparable or analogous functions to those discussed above.

It should be understood that system 12, as discussed and set forth with respect to FIG. 1, provides but an illustrative and non-restrictive example of a system that can be employed in connection with at least one embodiment of the present invention. The disclosure now turns to a discussion of embodiments of the present invention that can readily make use of a system such as system 12, or of a different or analogous system. The actions described herebelow can be carried out in essentially any suitable medium, such as the system processor 42 indicated at 42 in FIG. 1.

In the context of the challenges and problems discussed heretofore, there is broadly contemplated herein, in accordance with at least one embodiment of the present invention, an arrangement whereby upon the creation of a verification point (VP), it will not be checked against a predetermined or pre-configured VP (whether this would be image or VP data). Preferably, there will in fact be no pre-configured data source at all. Instead, a verification point reference, to be discussed more fully below, will preferably be utilized.

Throughout the ensuing discussion, reference can continue to be made not only to FIG. 1 but also to FIGS. 2-4.

Accordingly, FIG. 2 shows one of several ways of capturing data for UI objects (in XML format). The upper half of FIG. 2 conveys, by way of illustrative and non-restrictive example, data that are captured during two execution runs that may be referred to as “Run R1” and “Run R2”, respectively. It can be seen in FIG. 2, as will be further appreciated from the discussion herebelow, that different labels as presented to the user (“click here”, “Please click here”) can be employed without difficulty.

FIG. 3 shows a flow of events for executing a process in accordance with an embodiment of the present invention. This process will be better appreciated from the discussion herebelow, wherein responsive to a user prompt (e.g., “click here”, a “verification point reference” is set, followed by a general process for data capture (the flowchart at the right of the Figure) which then yields an output in the form of an object context.

FIG. 4 shows two embodiments in which the application context may be captured for creating a unique handle to one or more objects. The first embodiment is conveyed in the form of defining an application object context as ID's and the second is conveyed in the form of defining an application object context as a complete access path. Both of these definitions of an application object context will be further appreciated from the discussion herebelow.

Generally, in accordance with an embodiment of the present invention, a “verification point reference” is a data set which will be used for storing reference data for the purpose of validating a test case. For example, a VP can be created for a button label as: ButtonVP “Label=click here; width=100; height=50; coordinate=100, 200”. Consequently, if (for instance) the label were to change to “Please click here”, a tester needs to update all scripts where the original label is written, or at least update the test data store if the values (“click here”, 100, 50, “100, 200”) are picked from a data store. This can be appreciated from FIG. 2, where two different labels are employed for different execution runs R1 and R2.

In accordance with an embodiment of the present invention, and as shown in FIG. 3, the VP declaration may be modified as:

ButtonVP “DataSet=History”

The interpretation of history now becomes, “Data captured during Last/Previous run of the script” If the last/previous run is considered to be run “R1”, then in accordance with the VP modification just mentioned, if the label changes then it will be the case that during execution (run “R2” for the purposes of illustration) the VP will fail. When a testing suite runs at a subsequent time (run “R3”), the dataset will be set at “history”, meaning that the data store to be employed will be the same as that captured during execution of run R2. As such, test scripts will not fail from run R3 onwards, while not a single line of script will have needed to be changed.

Another benefit of the concept presented hereinabove is enjoyed in connection with finding all UI changes between two builds or versions of software. This can be done simply by pointing the “verification point reference” from “history” to any of the previous execution runs. For example, consider the release of an initial product (e.g., version 1.0.0.0), wherein the last test execution was “R100”. After release of the product, work for the next release starts. When this next version of the application (e.g., version 1.0.0.1) is ready with last execution run named “R200”, it is possible to find all UI changes between the two versions (1.0.0.0 and 1.0.0.1), simply by executing all test scripts on version 1.0.0.1 and pointing the VP dataset to R100 (which corresponds to 1.0.0.0). To make is easy for users to remember and use historical data references, execution run names can be annotated to more meaningful labels; for example, in the case just discussed, R100 can be annotated/labeled as “Release1.0.0.0”, R200 as “Release1.0.0.1”, etc.

It will be appreciated that by way of stark contrast, conventionally it is not known to directly find UI changes between two builds/versions of software, other than by reading all product documentation or going thru all “changeRequests” for a given product.

By way of an illustrative and non-restrictive example, a product manager may be interested to learn of all UI changes between versions “iFix3” and “iFix1”. This can be achieved simply by executing the test suite on iFix3 with a “verification point reference” to iFix1's final test execution run.

To elaborate further, conventionally, when VPs are defined, reference data is either stored in the script itself (or is tightly integrated with test script) and data captured during the application's running instance is compared with the saved VP data; thereupon a “pass” or “fail” is determined. By way of contrast, in accordance with at least one preferred embodiment of the present invention, it will be appreciated that, first, data is not stored with script; it merely has a “DataSet” reference name/label. Secondly, entire data which is fetched from the application during runtime for comparison is stored and thereafter referred to as a execution run (such as R100, R200 or “Release1.0.0.1” as discussed above). In other words, execution runs (e.g., R100, R200, etc.) essentially convey the state of an application during an execution run. Once execution run data are captured, then the application can be compared with any of the previous execution runs by simply changing the “DataSet” reference so that it points to any desired historical value.

To further appreciate the embodiments of the present invention, it will be appreciated that conventionally verification points are not kept for all objects in an application under test. This means that application is actually not tested completely. In accordance with embodiments of the present invention, however, one can simply apply VP for a particular type (e.g., “ButtonVP”) that will capture all buttons in a current context. If there are too many buttons to capture, then a filter can be defined to narrow down the data capture scope, e.g.:

ButtonVP DataSet=Release1.0.0.1 filer=[label=cancel]

Accordingly, a filter such as the above will ensure that all buttons in a current context with the label “cancel” will not be compared and, therefore, will not be reported in the test report. Wild cards can be used to specify certain classes of labels/properties (e.g., [label=*next*] can cover string labels like “click next”, “next >>”, “please click next” etc.)

In brief recapitulation, the following are among the very many advantages that can be attained by employing a process, in accordance with at least one embodiment of the present invention, as set forth and broadly contemplated herein:

-   -   No data store definition is required for UI (this is captured         automatically on runtime which is never incorrect).     -   No script changes are needed whenever UI changes.     -   A manner is provided for finding all UI changes between any two         builds/versions of the software in question.

It is to be understood that the present invention, in accordance with at least one embodiment, includes elements that may be implemented on at least one general-purpose computer running suitable software programs. These may also be implemented on at least one Integrated Circuit or part of at least one Integrated Circuit. Thus, it is to be understood that the invention may be implemented in hardware, software, or a combination of both.

Generally, embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment containing both hardware and software elements. An embodiment that is implemented in software may include, but is not limited to, firmware, resident software, microcode, etc.

Furthermore, embodiments may take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.

The medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include compact disk-read only memory (CD-ROM), compact disk-read/write (CD-R/W) and DVD.

A data processing system suitable for storing and/or executing program code may include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.

Input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) can be coupled to the system either directly or through intervening I/O controllers.

Network adapters may also be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices through intervening private or public networks. Modems, cable modems and Ethernet cards are just a few of the currently available types of network adapters.

This disclosure has been presented for purposes of illustration and description but is not intended to be exhaustive or limiting. Many modifications and variations will be apparent to those of ordinary skill in the art. The embodiments were chosen and described in order to explain principles and practical application, and to enable others of ordinary skill in the art to understand the disclosure for various embodiments with various modifications as are suited to the particular use contemplated.

Generally, although illustrative embodiments of the present invention have been described herein with reference to the accompanying drawings, it is to be understood that the invention is not limited to those precise embodiments. 

1. A method comprising: accepting software; and testing the software; said testing comprising: creating a verification point; storing reference data in the verification point; and subsequently employing the reference data in validating the software.
 2. The method according to claim 1, wherein creating of a verification point comprises leaving test script intact.
 3. The method according to claim 1, wherein said testing is immune to user interface changes between tests.
 4. The method according to claim 1, further comprising modifying the verification point.
 5. The method according to claim 4, wherein said modifying comprises including a reference to historical data in the verification point.
 6. The method according to claim 5, further comprising employing the verification point to refer to historical changes between product versions.
 7. The method according to claim 6, wherein said employing comprises employing the verification point to refer to historical changes between two product versions that are earlier versions than a current product version.
 8. The method according to claim 1, wherein said creating of a verification point comprises including a filter to narrow a scope of data capture.
 9. An apparatus comprising: a main memory; a software testing arrangement in communication with said main memory; said software testing arrangement acting to: create a verification point; store reference data in the verification point; and subsequently employ the reference data in validating software.
 10. The apparatus according to claim 9, wherein said software testing arrangement acts to create a verification point via leaving test script intact.
 11. The apparatus according to claim 9, wherein said software testing arrangement acts to test software while being immune to user interface changes between tests.
 12. The apparatus according to claim 9, wherein said software testing arrangement further acts to modify the verification point.
 13. The apparatus according to claim 12, wherein said software testing arrangement acts to modify the verification point via including a reference to historical data in the verification point.
 14. The apparatus according to claim 13, wherein said software testing arrangement further acts to employ the verification point to refer to historical changes between product versions.
 15. The apparatus according to claim 14, wherein said software testing arrangement acts to employ the verification point to refer to historical changes between two product versions that are earlier versions than a current product version.
 16. The apparatus according to claim 9, wherein said software testing arrangement acts to create a verification point via including a filter to narrow a scope of data capture.
 17. A program storage device readable by machine, tangibly embodying a program of instructions executable by the machine to perform a method comprising: accepting software; and testing the software; said testing comprising: creating a verification point; storing reference data in the verification point; and subsequently employing the reference data in validating the software.
 18. The program storage device according to claim 17, wherein creating of a verification point comprises leaving test script intact.
 19. The program storage device according to claim 17, wherein said testing is immune to user interface changes between tests.
 20. The program storage device according to claim 17, further comprising modifying the verification point. 